cpp/src/mip/diversity/recombiners/sub_mip.cuh (1)

107-107: Consider consolidating time limit settings.

Both line 107 and line 102 specify sub_mip_recombiner_config_t::sub_mip_time_limit. If the termination checker at line 104 now handles all time limit enforcement, the explicit time_limit assignment here might be redundant. However, without visibility into branch_and_bound_t's implementation, it's unclear whether both settings are still needed.

🔎 Verification script to check time_limit usage in branch_and_bound

#!/bin/bash
# Description: Check how branch_and_bound uses time_limit vs termination settings

# Search for time_limit field usage in branch_and_bound implementation
rg -nP --type=cpp --type=cu -C5 '\btime_limit\b' -g '*branch_and_bound*'

# Search for termination field usage in branch_and_bound implementation  
rg -nP --type=cpp --type=cu -C5 '\btermination\b' -g '*branch_and_bound*'

cpp/src/mip/feasibility_jump/feasibility_jump.cu (1)

1050-1050: Consider more accurate effort rate calculation.

The timer created here measures total elapsed time including setup work (lines 1051-1093), but line 1098 calculates effort_rate as iterations / timer.elapsed_time(). Since iterations only counts work done inside host_loop(), the effort rate includes setup overhead and doesn't reflect the true iteration rate.

Consider using the timer from host_loop() (line 865) or returning its elapsed time for a more accurate iteration throughput metric.

python/cuopt/cuopt/linear_programming/solver/solver_wrapper.pyx (1)

211-218: LP callbacks correctly wired; consider de-duplicating callback registration

The new lp_callbacks = settings.get_lp_callbacks() loop mirrors the existing MIP callback wiring and the cast to base_solution_callback_t* is consistent, so LP solution callbacks should now flow through correctly.

You now have nearly identical MIP/LP callback registration blocks; factoring this into a small helper (e.g., _register_callbacks(c_solver_settings, callbacks, set_fn)) would reduce drift risk if callback handling evolves.

cpp/src/dual_simplex/barrier.cu (1)

3691-3694: Centralized termination checks are correct; consider more generic logging/helper

Switching from ad‑hoc time checks to settings.check_termination(start_time) before initial_point and at key points in the main loop is a solid move: it now respects the unified termination mechanism (time limit, callbacks, SIGINT via the parent checker) and still returns lp_status_t::TIME_LIMIT or CONCURRENT_LIMIT as before.

Two small follow‑ups to consider:

• All these sites log "Barrier time limit exceeded" and return TIME_LIMIT even when the stop is driven by a user callback or SIGINT rather than the numeric time limit. If callbacks/SIGINT are intentionally folded into TIME_LIMIT, a more neutral message like "Barrier terminated by limit/callback" would avoid misleading logs.
• The check_termination + log + TIME_LIMIT pattern is repeated several times; a tiny helper (e.g., if (auto s = settings.handle_termination_if_requested(start_time)) return s;) would de‑duplicate this and keep future changes localized.

Also applies to: 3697-3700, 3796-3799, 3832-3835, 3873-3876

cpp/tests/mip/bounds_standardization_test.cu (1)

69-80: Relaxed-LP test termination checker wiring is correct; add <limits> include

Constructing a root termination_checker_t with std::numeric_limits<double>::infinity() and threading it into detail::get_relaxed_lp_solution matches the new API and preserves the intended behavior: a global “no hard wall-clock cap” while lp_settings.time_limit still enforces the 120s limit inside the relaxed LP solve.

Since this file now uses std::numeric_limits, it would be cleaner to explicitly #include <limits> rather than relying on transitive includes from other headers.

If more tests need a root termination checker, consider a small utility (e.g., make_infinite_termination_checker()) in a shared test helper to avoid repeating the construction pattern.

cpp/src/dual_simplex/crossover.cpp (4)

532-535: Log message is misleading after termination logic unification.

Line 533 says "Crossover time exceeded" but check_termination now checks multiple termination conditions (time limit, user callbacks, SIGINT) per the PR objectives, not just time. Consider updating to "Crossover terminated" or "Crossover stopped" to reflect the broader termination logic.

Suggested message update

     if (settings.check_termination(start_time)) {
-      settings.log.printf("Crossover time exceeded\n");
+      settings.log.printf("Crossover terminated\n");
       return -1;
     }

---

532-539: Redundant concurrent_halt check after check_termination.

Lines 536-539 manually check concurrent_halt after check_termination returns. Per the snippet from simplex_solver_settings.hpp (lines 89-95), check_termination already sets *concurrent_halt = 1 when termination is requested, making this subsequent check redundant.

Remove redundant check

     if (settings.check_termination(start_time)) {
       settings.log.printf("Crossover terminated\n");
       return -1;
     }
-    if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) {
-      settings.log.printf("Concurrent halt\n");
-      return -2;
-    }

Note: This pattern repeats at lines 823-830, 1146-1153, 1233-1240, and 1361-1368. Consider applying the same refactor to all occurrences.

---

823-826: Update log message to reflect unified termination logic.

Same issue as line 533: the message says "time limit exceeded" but check_termination now checks multiple termination conditions.

Suggested update

     if (settings.check_termination(start_time)) {
-      settings.log.printf("Crossover time limit exceeded\n");
+      settings.log.printf("Crossover terminated\n");
       return -1;
     }

---

1146-1149: Update log message to reflect unified termination logic.

Same issue: "Time limit exceeded" should reflect that termination can occur due to multiple conditions.

Suggested update

     if (settings.check_termination(start_time)) {
-      settings.log.printf("Time limit exceeded\n");
+      settings.log.printf("Crossover terminated\n");
       return crossover_status_t::TIME_LIMIT;
     }

cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp (1)

102-102: Consider initializing pyCallbackClass to avoid undefined behavior.

The pyCallbackClass member is uninitialized. If check_termination() is called before the callback is properly set up, this will cause undefined behavior.

🔎 Suggested initialization

-  PyObject* pyCallbackClass;
+  PyObject* pyCallbackClass = nullptr;

cpp/include/cuopt/linear_programming/utilities/internals.hpp (1)

59-66: LGTM! Clean callback interface following existing patterns.

The new check_termination_callback_t class follows the established pattern of get_solution_callback_t and set_solution_callback_t, providing a consistent API for termination checking.

Consider adding Doxygen documentation for this public API class to describe the expected behavior and return value semantics of check_termination(). Based on coding guidelines for public headers.

cpp/include/cuopt/utilities/user_interrupt_handler.hpp (1)

117-122: Consider making next_id_ atomic for thread-safety.

While register_callback and unregister_callback are protected by mutex_, if you address the signal handler issue above, you may want next_id_ to be std::atomic<size_t> for consistency with thread-safe patterns.

cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp (2)

174-182: Add Doxygen documentation for new public API methods.

As per coding guidelines for public headers (cpp/include/cuopt/**/*), new public functions should have documentation comments. These methods are part of the public C++ API and should document:

• Purpose and usage
• Lifetime requirements for callback pointers
• Thread-safety considerations

🔎 Suggested documentation

+  /**
+   * @brief Get the list of registered LP solution callbacks.
+   * @return Vector of pointers to registered callbacks.
+   * @note Callbacks must remain valid for the lifetime of the solver.
+   */
   const std::vector<internals::base_solution_callback_t*> get_lp_callbacks() const
   {
     return lp_callbacks_;
   }

+  /**
+   * @brief Register an LP solution callback.
+   * @param callback Pointer to callback object. Caller retains ownership
+   *                 and must ensure the callback remains valid during solving.
+   */
   void set_lp_callback(internals::base_solution_callback_t* callback)
   {
     lp_callbacks_.push_back(callback);
   }

---

229-230: Consider making lp_callbacks_ private for encapsulation consistency.

The member lp_callbacks_ is declared public but has getter/setter methods (get_lp_callbacks, set_lp_callback). This breaks encapsulation - callers could bypass the accessors and modify the vector directly.

🔎 Move to private section

- std::vector<internals::base_solution_callback_t*> lp_callbacks_;
-
  private:
   /** Initial primal solution */
   std::shared_ptr<rmm::device_uvector<f_t>> initial_primal_solution_;
   /** Initial dual solution */
   std::shared_ptr<rmm::device_uvector<f_t>> initial_dual_solution_;
+  /** LP solution callbacks */
+  std::vector<internals::base_solution_callback_t*> lp_callbacks_;

cpp/src/utilities/termination_checker.hpp (1)

29-74: Consider making termination_checker_t non-copyable to prevent dangling parent pointers.

The class stores a raw pointer to a parent termination_checker_t. If an instance is copied, both the original and copy will reference the same parent. If the parent is destroyed before the copy, the copy will have a dangling pointer. Since this class represents a scoped termination context tied to a specific solver invocation, non-copyable semantics would be safer.

🔎 Suggested fix

 class termination_checker_t {
  public:
+  // Non-copyable to prevent dangling parent pointers
+  termination_checker_t(const termination_checker_t&) = delete;
+  termination_checker_t& operator=(const termination_checker_t&) = delete;
+  termination_checker_t(termination_checker_t&&) = default;
+  termination_checker_t& operator=(termination_checker_t&&) = default;
+
   // Separate tag to force any declaration of a root termination checker to be explicit
   struct root_tag_t {};

cpp/src/mip/local_search/rounding/constraint_prop.cu (1)

42-43: Clarify the initialization of max_timer with zero time limit.

The constructor initializes max_timer with time_limit=0, which would cause check() to return true immediately. This is overwritten in apply_round() on line 1067 before actual use, so it's functionally correct, but the pattern is confusing.

Consider using a sentinel or making the initial state more explicit.

cpp/src/mip/presolve/probing_cache.cu (1)

491-512: Optimize termination handling in parallel loop.

When timer.check() returns true at line 495, the current code uses continue, causing all remaining iterations to execute the termination check unnecessarily. In an OpenMP parallel loop, this wastes cycles across all threads.

♻️ Proposed refactor to use a shared termination flag

   // Atomic variables for tracking progress
   std::atomic<size_t> n_of_implied_singletons(0);
   std::atomic<size_t> n_of_cached_probings(0);
+  std::atomic<bool> should_terminate(false);
 
 // Main parallel loop
 #pragma omp parallel
   {
 #pragma omp for schedule(static, 4)
     for (auto var_idx : priority_indices) {
-      if (timer.check()) { continue; }
+      if (should_terminate.load(std::memory_order_relaxed) || timer.check()) { 
+        should_terminate.store(true, std::memory_order_relaxed);
+        continue; 
+      }
 
       int thread_idx = omp_get_thread_num();
       CUOPT_LOG_TRACE("Computing probing cache for var %d on thread %d", var_idx, thread_idx);

Alternatively, check the flag first to avoid redundant timer.check() calls:

-      if (timer.check()) { continue; }
+      if (should_terminate.load(std::memory_order_relaxed)) { continue; }
+      if (timer.check()) { 
+        should_terminate.store(true, std::memory_order_relaxed);
+        continue; 
+      }

cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh (1)

180-181: LGTM! Termination checker correctly integrated.

The replacement of timer_t with termination_checker_t is implemented correctly in both code paths. The timer objects are properly initialized with the time limit and termination context, and passed to constraint_prop.apply_round() for termination checking.

Optional enhancement for more responsive termination:

In the first code path (lines 178-213), several operations occur between timer creation and the first termination check in apply_round(): compute_vars_to_fix, fix_variables, device copies, sync_stream, get_probing_values_for_feasible, and host_copy. If any of these operations are time-consuming, termination response could be delayed. Consider adding an explicit termination check after the most expensive operations to improve responsiveness to SIGINT.

💡 Example of adding explicit termination check

 offspring.handle_ptr->sync_stream();
+if (timer.is_terminated()) {
+  CUOPT_LOG_DEBUG("Termination requested during recombination");
+  return std::make_pair(offspring, false);
+}
 offspring.assignment  = std::move(fixed_assignment);

Note: This assumes termination_checker_t exposes a method like is_terminated() for explicit checking. Adjust based on the actual API.

Also applies to: 215-216

cpp/src/mip/local_search/local_search.cu (2)

670-671: Redundant termination check in loop.

The loop condition at line 670 already includes !timer.check(), making the check at line 671 redundant. Consider removing it to avoid unnecessary duplicate checks.

♻️ Simplify by removing redundant check

 for (i_t i = 0; i < n_fp_iterations && !timer.check(); ++i) {
-  if (timer.check()) {
-    is_feasible = false;
-    break;
-  }
   CUOPT_LOG_DEBUG("fp_loop it %d last_improved_iteration %d", i, last_improved_iteration);

---

250-256: Redundant termination check in generate_fast_solution.

The loop condition at line 250 already checks !timer.check(), making the check at line 256 redundant. The loop will naturally exit when the timer expires.

♻️ Remove redundant check

 while (!timer.check()) {
   termination_checker_t constr_prop_timer =
     termination_checker_t(std::min(timer.remaining_time(), 2.), context.termination);
   constraint_prop.apply_round(solution, 1., constr_prop_timer);
   if (solution.compute_feasibility()) { return; }
-  if (timer.check()) { return; };
   f_t time_limit = std::min(3., timer.remaining_time());

cpp/tests/mip/mip_utils.cuh (1)

118-120: Consider adding null check for callbacks.

The loop iterates over all callbacks without filtering nulls. If the caller inadvertently passes a vector containing null pointers, this could cause issues when set_mip_callback is invoked.

♻️ Optional defensive check

   for (auto callback : callbacks) {
+    if (callback == nullptr) { continue; }
     settings.set_mip_callback(callback);
   }

cpp/src/dual_simplex/basis_solves.cpp (1)

364-367: Clarify and de-magic the -2 concurrent-halt return from factorize_basis

factorize_basis now uses -2 to signal settings.concurrent_halt == 1, distinct from rank-deficiency -1. Callers in this PR already treat -2 as a concurrent limit, but the raw integer makes it easy for other sites to mis-handle this status.

Consider:

• Introducing a small enum or constexpr i_t for CONCURRENT_HALT and RANK_DEFICIENT, and
• Verifying all uses of factorize_basis across the codebase handle -2 explicitly as a concurrent-limit condition.

Also applies to: 583-586

cpp/src/dual_simplex/primal.cpp (1)

298-311: Concurrent-halt propagation from factorize_basis in primal_phase2 looks correct

Mapping rank == -2 and repair_rank == -2 to primal::status_t::CONCURRENT_HALT, and repair_rank == -1 to NUMERICAL, is consistent with the new factorization status semantics.

Minor nit: in the repaired path the log still prints rank instead of repair_rank, which can be misleading when the second factorization fails differently than the first. If you touch this again, consider logging repair_rank there.

cpp/src/dual_simplex/phase2.cpp (1)

2885-2907: Confirm refactor_basis cannot return -1, or handle it explicitly in the repair loop

In the refactor/repair block:

i_t refactor_result = ft.refactor_basis(...);
if (refactor_result == -2) { return dual::status_t::CONCURRENT_LIMIT; }
if (refactor_result > 0) {
  ...
  i_t deficient_size;
  while ((deficient_size = ft.refactor_basis(...)) > 0) {
    ...
  }
  if (deficient_size == -2) { return dual::status_t::CONCURRENT_LIMIT; }
  settings.log.printf("Successfully repaired basis. Iteration %d\n", iter);
}

This assumes ft.refactor_basis only returns:

• 0 on success,
• >0 for “deficient columns remaining”, and
• -2 for concurrent halt.

If refactor_basis can ever return -1 for unrecoverable numerical issues, this code will:

• Exit the while (since -1 > 0 is false),
• Skip the deficient_size == -2 check, and
• Log “Successfully repaired basis” even though refactor failed.

Please confirm the contract of refactor_basis. If -1 is a possible return, it should be handled explicitly (e.g., mapping to dual::status_t::NUMERICAL) before treating the repair as successful.

cpp/src/dual_simplex/crossover.cpp (1)

532-539: Check that check_termination is purely time/user-stop, not concurrent-halt aware

In dual_push’s loop:

if (settings.check_termination(start_time)) {
  settings.log.printf("Crossover time exceeded\n");
  return -1;
}
if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) {
  settings.log.printf("Concurrent halt\n");
  return -2;
}

Callers then convert these to TIME_LIMIT vs CONCURRENT_LIMIT through return_to_status.

This separation is fine if settings.check_termination(start_time) only covers time / user-stop / work limits. If it also interprets settings.concurrent_halt internally, the first branch would fire and you’d report TIME_LIMIT instead of CONCURRENT_LIMIT, making the second branch unreachable.

Please confirm the intended contract of check_termination and whether it is guaranteed not to subsume the concurrent-halt condition.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Learnt from: chris-maes
Repo: NVIDIA/cuopt PR: 500
File: cpp/src/dual_simplex/sparse_matrix.cpp:519-524
Timestamp: 2025-12-03T23:29:26.391Z
Learning: In cpp/src/dual_simplex/sparse_matrix.cpp, the check_matrix() function is debug/diagnostic code (wrapped in #ifdef CHECK_MATRIX) that intentionally prints errors without necessarily returning early. The return codes from this debug code are not actively checked; the purpose is to print all validation errors in one pass for better diagnostics.

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Check that hard-coded GPU device IDs and resource limits are made configurable; abstract multi-backend support for different CUDA versions

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cpp,hpp,h} : Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify error propagation from CUDA to user-facing APIs is complete; ensure CUDA errors are caught and mapped to meaningful user error codes

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.cu : Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)

Learnt from: chris-maes
Repo: NVIDIA/cuopt PR: 602
File: cpp/src/linear_programming/solve.cu:732-742
Timestamp: 2025-12-04T20:09:09.264Z
Learning: In cpp/src/linear_programming/solve.cu, the barrier solver does not currently return INFEASIBLE or UNBOUNDED status. It only returns OPTIMAL, TIME_LIMIT, NUMERICAL_ISSUES, or CONCURRENT_LIMIT.

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Ensure test isolation: prevent GPU state, cached memory, and global variables from leaking between test cases; verify each test independently initializes its environment

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Test with free variables, singleton problems, and extreme problem dimensions near resource limits to validate edge case handling

Learnt from: chris-maes
Repo: NVIDIA/cuopt PR: 500
File: cpp/src/dual_simplex/scaling.cpp:68-76
Timestamp: 2025-12-04T04:11:12.640Z
Learning: In the cuOPT dual simplex solver, CSR/CSC matrices (including the quadratic objective matrix Q) are required to have valid dimensions and indices by construction. Runtime bounds checking in performance-critical paths like matrix scaling is avoided to prevent slowdowns. Validation is performed via debug-only check_matrix() calls wrapped in #ifdef CHECK_MATRIX.

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cpp,hpp,h} : Check for unclosed file handles when reading MPS/QPS problem files; ensure RAII patterns or proper cleanup in exception paths

Learnt from: aliceb-nv
Repo: NVIDIA/cuopt PR: 527
File: cpp/src/mip/diversity/lns/rins.cu:167-175
Timestamp: 2025-10-22T14:25:22.899Z
Learning: In MIP (Mixed Integer Programming) problems in the cuOPT codebase, `n_integer_vars == 0` is impossible by definition—MIP problems must have at least one integer variable. If there are no integer variables, it would be a pure Linear Programming (LP) problem, not a MIP problem.

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for problem transformations: verify correctness of original→transformed→postsolve mappings and index consistency across problem representations

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*benchmark*.{cpp,cu,py} : Include performance benchmarks and regression detection for GPU operations; verify near real-time performance on million-variable problems